package com.smart.community.region.controller;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

import javax.validation.Valid;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.smart.community.commons.annotation.ApiLog;
import com.smart.community.commons.enums.ApiLogOperationType;
import com.smart.community.commons.result.PageResult;
import com.smart.community.commons.result.Result;
import com.smart.community.commons.utils.SecurityUtils;
import com.smart.community.region.dto.CommunityDTO;
import com.smart.community.region.dto.CommunityQueryDTO;
import com.smart.community.region.entity.Building;
import com.smart.community.region.entity.Community;
import com.smart.community.region.service.ICommunityService;
import com.smart.community.region.vo.CommunityVO;
import com.smart.community.region.vo.CommunityDeleteImpactVO;

import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;

/**
 * 社区管理控制器
 * 
 * @author Wu.Liang
 * @version 1.0.0
 * @since 2025-01-30
 */
@Slf4j
@RestController
@RequestMapping("/region/communities")
@Tag(name = "社区管理", description = "社区管理相关接口")
public class CommunityController {

    @Autowired
    private ICommunityService communityService;
    
    @Autowired
    private com.smart.community.feign.user.service.UserFeignService userFeignService;

    // ==================== 基础CRUD接口 ====================

    /**
     * 分页查询社区列表
     * 
     * @param queryDTO 查询条件
     * @return 社区分页列表
     * @throws Exception 统一异常
     */
    @GetMapping
    @Operation(summary = "分页查询社区列表", description = "根据条件分页查询社区列表")
    public Result<PageResult<CommunityVO>> getCommunityPage(@Parameter(description = "查询条件") CommunityQueryDTO queryDTO) throws Exception {
        try {
            log.info("开始分页查询社区列表，查询条件：{}", queryDTO);
            
            // 权限控制
            Long currentUserId = SecurityUtils.getCurrentUserId();
            if (currentUserId == null) {
                return Result.fail("用户未登录");
            }
            
            PageResult<CommunityVO> result = communityService.getCommunityPage(queryDTO);
            
            log.info("分页查询社区列表成功，返回记录数：{}", result.getRecords().size());
            return Result.success("查询成功", result);
        } catch (Exception e) {
            log.error("分页查询社区列表失败，查询条件：{}，错误信息：{}", queryDTO, e.getMessage(), e);
            return Result.fail("查询失败：" + e.getMessage());
        }
    }

    /**
     * 获取全部社区列表（不分页，用于下拉框选择）
     * 
     * @param queryDTO 查询条件
     * @return 社区列表
     * @throws Exception 统一异常
     */
    @GetMapping("/list")
    @Operation(summary = "获取全部社区列表", description = "获取全部社区列表，用于下拉框选择，不分页")
    public Result<List<CommunityVO>> getCommunityList(@Parameter(description = "查询条件") CommunityQueryDTO queryDTO) throws Exception {
        try {
            log.info("开始获取全部社区列表，查询条件：{}", queryDTO);
            
            // 权限控制
            Long currentUserId = SecurityUtils.getCurrentUserId();
            if (currentUserId == null) {
                log.warn("用户未登录，无法获取社区列表");
                return Result.fail("用户未登录");
            }
            
            // 添加数据权限验证日志
            log.info("用户{}请求社区列表，开始验证数据权限", currentUserId);
            
            List<CommunityVO> result = communityService.getCommunityList(queryDTO);
            
            log.info("获取全部社区列表成功，用户ID：{}，记录数：{}", currentUserId, result.size());
            return Result.success("查询成功", result);
        } catch (Exception e) {
            log.error("获取全部社区列表失败，查询条件：{}，错误信息：{}", queryDTO, e.getMessage(), e);
            return Result.fail("查询失败：" + e.getMessage());
        }
    }

    /**
     * 获取社区详情
     * 
     * @param communityId 社区ID
     * @return 社区详情
     * @throws Exception 统一异常
     */
    @GetMapping("/{communityId}")
    @Operation(summary = "获取社区详情", description = "根据社区ID获取社区详细信息")
    public Result<CommunityVO> getCommunityDetail(@Parameter(description = "社区ID") @PathVariable Long communityId) throws Exception {
        try {
            log.info("开始获取社区详情，社区ID：{}", communityId);
            
            // 参数校验
            if (communityId == null || communityId <= 0) {
                return Result.fail("社区ID必须大于0");
            }
            
            // 权限控制
            Long currentUserId = SecurityUtils.getCurrentUserId();
            if (currentUserId == null) {
                return Result.fail("用户未登录");
            }
            
            CommunityVO community = communityService.getCommunityById(communityId);
            if (community == null) {
                return Result.fail("社区不存在");
            }
            
            log.info("获取社区详情成功，社区ID：{}", communityId);
            return Result.success("查询成功", community);
        } catch (Exception e) {
            log.error("获取社区详情失败，社区ID：{}，错误信息：{}", communityId, e.getMessage(), e);
            return Result.fail("查询失败：" + e.getMessage());
        }
    }

    /**
     * 创建社区
     * 
     * @param communityDTO 社区信息
     * @return 创建结果
     * @throws Exception 统一异常
     */
    /**
     * 创建社区
     * 
     * @param communityDTO 社区信息
     * @return 创建结果
     * @throws Exception 统一异常
     */
    @ApiLog(logTitle = "创建社区", logType = 2, moduleName = "区域管理", operationType = ApiLogOperationType.ADD)
    @PostMapping
    @Operation(summary = "创建社区", description = "创建新的社区")
    public Result<CommunityVO> createCommunity(@Parameter(description = "社区信息") @RequestBody @Valid CommunityDTO communityDTO) throws Exception {
        try {
            log.info("开始创建社区，操作人：{}，社区信息：{}", SecurityUtils.getCurrentUserId(), communityDTO);
            
            // 权限控制
            Long currentUserId = SecurityUtils.getCurrentUserId();
            if (currentUserId == null) {
                return Result.fail("用户未登录");
            }
            
            // 权限控制：检查用户是否有创建社区的权限
            if (!hasCreateCommunityPermission()) {
                return Result.fail("无权限创建社区");
            }
            
            Result<CommunityVO> result = communityService.addCommunity(communityDTO);
            
            log.info("创建社区成功，操作人：{}", currentUserId);
            return result;
        } catch (Exception e) {
            log.error("创建社区失败，操作人：{}，错误信息：{}", SecurityUtils.getCurrentUserId(), e.getMessage(), e);
            return Result.fail("创建社区失败：" + e.getMessage());
        }
    }

    /**
     * 更新社区
     * 
     * @param communityId 社区ID
     * @param communityDTO 社区信息
     * @return 更新结果
     * @throws Exception 统一异常
     */
    /**
     * 更新社区
     * 
     * @param communityId 社区ID
     * @param communityDTO 社区信息
     * @return 更新结果
     * @throws Exception 统一异常
     */
    @ApiLog(logTitle = "更新社区", logType = 2, moduleName = "区域管理", operationType = ApiLogOperationType.UPDATE)
    @PutMapping("/{communityId}")
    @Operation(summary = "更新社区", description = "更新社区信息")
    public Result<CommunityVO> updateCommunity(@Parameter(description = "社区ID") @PathVariable Long communityId,
            @Parameter(description = "社区信息") @RequestBody @Valid CommunityDTO communityDTO) throws Exception {
        try {
            log.info("开始更新社区，操作人：{}，社区ID：{}，社区信息：{}", SecurityUtils.getCurrentUserId(), communityId, communityDTO);
            
            // 参数校验
            if (communityId == null || communityId <= 0) {
                return Result.fail("社区ID必须大于0");
            }
            
            // 权限控制
            Long currentUserId = SecurityUtils.getCurrentUserId();
            if (currentUserId == null) {
                return Result.fail("用户未登录");
            }
            
            // 权限控制：只有管理员可以更新社区
            if (!SecurityUtils.hasRole("admin")) {
                return Result.fail("无权限更新社区");
            }
            
            communityDTO.setId(communityId);
            Result<CommunityVO> result = communityService.updateCommunity(communityDTO);
            
            log.info("更新社区成功，社区ID：{}，操作人：{}", communityId, currentUserId);
            return result;
        } catch (Exception e) {
            log.error("更新社区失败，操作人：{}，社区ID：{}，错误信息：{}", SecurityUtils.getCurrentUserId(), communityId, e.getMessage(), e);
            return Result.fail("更新社区失败：" + e.getMessage());
        }
    }

    /**
     * 删除社区（带关联检查）
     * 
     * @param communityId 社区ID
     * @return 删除结果
     * @throws Exception 统一异常
     */
    /**
     * 删除社区（带关联检查）
     * 
     * @param communityId 社区ID
     * @return 删除结果
     * @throws Exception 统一异常
     */
    @DeleteMapping("/{communityId}")
    @Operation(summary = "删除社区", description = "删除指定社区，会检查并处理所有关联数据")
    @ApiLog(logTitle = "删除社区", logType = 2, moduleName = "区域管理", operationType = ApiLogOperationType.DELETE)
    public Result<String> deleteCommunity(@Parameter(description = "社区ID") @PathVariable Long communityId) throws Exception {
        try {
            log.info("开始删除社区，操作人：{}，社区ID：{}", SecurityUtils.getCurrentUserId(), communityId);
            
            // 参数校验
            if (communityId == null || communityId <= 0) {
                return Result.fail("社区ID必须大于0");
            }
            
            // 权限控制
            Long currentUserId = SecurityUtils.getCurrentUserId();
            if (currentUserId == null) {
                return Result.fail("用户未登录");
            }
            
            // 权限控制：只有管理员可以删除社区
            if (!SecurityUtils.hasRole("admin")) {
                return Result.fail("无权限删除社区");
            }
            
            String result = communityService.deleteCommunityWithRelations(communityId, currentUserId);
            
            log.info("删除社区成功，社区ID：{}，操作人：{}", communityId, currentUserId);
            return Result.success("删除成功", result);
        } catch (Exception e) {
            log.error("删除社区失败，操作人：{}，社区ID：{}，错误信息：{}", SecurityUtils.getCurrentUserId(), communityId, e.getMessage(), e);
            return Result.fail("删除社区失败：" + e.getMessage());
        }
    }

    /**
     * 批量删除社区（带关联检查）
     * 
     * @param communityIds 社区ID列表
     * @return 删除结果
     * @throws Exception 统一异常
     */
    /**
     * 批量删除社区（带关联检查）
     * 
     * @param communityIds 社区ID列表
     * @return 删除结果
     * @throws Exception 统一异常
     */
    @DeleteMapping("/batch")
    @Operation(summary = "批量删除社区", description = "批量删除社区，会检查并处理所有关联数据")
    @ApiLog(logTitle = "批量删除社区", logType = 2, moduleName = "区域管理", operationType = ApiLogOperationType.DELETE)
    public Result<String> batchDeleteCommunities(@Parameter(description = "社区ID列表") @RequestBody List<Long> communityIds) throws Exception {
        try {
            log.info("开始批量删除社区，操作人：{}，社区ID列表：{}", SecurityUtils.getCurrentUserId(), communityIds);
            
            // 参数校验
            if (communityIds == null || communityIds.isEmpty()) {
                return Result.fail("社区ID列表不能为空");
            }
            
            // 权限控制
            Long currentUserId = SecurityUtils.getCurrentUserId();
            if (currentUserId == null) {
                return Result.fail("用户未登录");
            }
            
            // 权限控制：只有管理员可以批量删除社区
            if (!SecurityUtils.hasRole("admin")) {
                return Result.fail("无权限批量删除社区");
            }
            
            String result = communityService.batchDeleteCommunitiesWithRelations(communityIds, currentUserId);
            
            log.info("批量删除社区成功，社区ID列表：{}，操作人：{}", communityIds, currentUserId);
            return Result.success("批量删除成功", result);
        } catch (Exception e) {
            log.error("批量删除社区失败，操作人：{}，社区ID列表：{}，错误信息：{}", SecurityUtils.getCurrentUserId(), communityIds, e.getMessage(), e);
            return Result.fail("批量删除社区失败：" + e.getMessage());
        }
    }

    // ==================== 查询接口 ====================

    /**
     * 根据社区编码获取社区
     * 
     * @param communityCode 社区编码
     * @return 社区信息
     * @throws Exception 统一异常
     */
    @GetMapping("/code/{communityCode}")
    @Operation(summary = "根据社区编码获取社区", description = "根据社区编码获取社区信息")
    public Result<CommunityVO> getCommunityByCode(@Parameter(description = "社区编码") @PathVariable String communityCode) throws Exception {
        try {
            log.info("开始根据社区编码获取社区，社区编码：{}", communityCode);
            
            // 参数校验
            if (communityCode == null || communityCode.trim().isEmpty()) {
                return Result.fail("社区编码不能为空");
            }
            
            // 权限控制
            Long currentUserId = SecurityUtils.getCurrentUserId();
            if (currentUserId == null) {
                return Result.fail("用户未登录");
            }
            
            CommunityVO community = communityService.getCommunityByCode(communityCode);
            if (community == null) {
                return Result.fail("社区不存在");
            }
            
            log.info("根据社区编码获取社区成功，社区编码：{}", communityCode);
            return Result.success("查询成功", community);
        } catch (Exception e) {
            log.error("根据社区编码获取社区失败，社区编码：{}，错误信息：{}", communityCode, e.getMessage(), e);
            return Result.fail("查询失败：" + e.getMessage());
        }
    }

    /**
     * 根据区域ID获取社区列表
     * 
     * @param regionId 区域ID
     * @return 社区列表
     * @throws Exception 统一异常
     */
    @GetMapping("/region/{regionId}")
    @Operation(summary = "根据区域获取社区列表", description = "获取指定区域下的所有社区")
    public Result<List<Community>> getCommunitiesByRegion(@Parameter(description = "区域ID") @PathVariable Long regionId) throws Exception {
        try {
            log.info("开始根据区域获取社区列表，区域ID：{}", regionId);
            
            // 参数校验
            if (regionId == null || regionId <= 0) {
                return Result.fail("区域ID必须大于0");
            }
            
            // 权限控制
            Long currentUserId = SecurityUtils.getCurrentUserId();
            if (currentUserId == null) {
                return Result.fail("用户未登录");
            }
            
            List<Community> result = communityService.getCommunitiesByRegion(regionId);
            
            log.info("根据区域获取社区列表成功，区域ID：{}，社区数量：{}", regionId, result.size());
            return Result.success("查询成功", result);
        } catch (Exception e) {
            log.error("根据区域获取社区列表失败，区域ID：{}，错误信息：{}", regionId, e.getMessage(), e);
            return Result.fail("查询失败：" + e.getMessage());
        }
    }

    /**
     * 获取社区楼栋列表
     * 
     * @param communityId 社区ID
     * @return 楼栋列表
     * @throws Exception 统一异常
     */
    @GetMapping("/{communityId}/buildings")
    @Operation(summary = "获取社区楼栋列表", description = "获取指定社区下的所有楼栋信息")
    public Result<List<Building>> getCommunityBuildings(@Parameter(description = "社区ID") @PathVariable Long communityId) throws Exception {
        try {
            log.info("开始获取社区楼栋列表，社区ID：{}", communityId);
            
            // 参数校验
            if (communityId == null || communityId <= 0) {
                return Result.fail("社区ID必须大于0");
            }
            
            // 权限控制
            Long currentUserId = SecurityUtils.getCurrentUserId();
            if (currentUserId == null) {
                return Result.fail("用户未登录");
            }
            
            List<Building> result = communityService.getCommunityBuildings(communityId);
            
            log.info("获取社区楼栋列表成功，社区ID：{}，楼栋数量：{}", communityId, result.size());
            return Result.success("查询成功", result);
        } catch (Exception e) {
            log.error("获取社区楼栋列表失败，社区ID：{}，错误信息：{}", communityId, e.getMessage(), e);
            return Result.fail("查询失败：" + e.getMessage());
        }
    }

    // ==================== 状态管理接口 ====================

    /**
     * 更新社区状态
     * 
     * @param communityId 社区ID
     * @param status 状态：0-禁用，1-启用
     * @return 更新结果
     * @throws Exception 统一异常
     */
    @ApiLog(logTitle = "更新社区状态", logType = 2, moduleName = "区域管理", operationType = ApiLogOperationType.UPDATE)
    @PutMapping("/{communityId}/status")
    @Operation(summary = "更新社区状态", description = "更新社区启用/禁用状态")
    public Result<Boolean> updateCommunityStatus(@Parameter(description = "社区ID") @PathVariable Long communityId,
            @Parameter(description = "状态：0-禁用，1-启用") @RequestParam Integer status) throws Exception {
        try {
            log.info("开始更新社区状态，操作人：{}，社区ID：{}，状态：{}", SecurityUtils.getCurrentUserId(), communityId, status);
            
            // 参数校验
            if (communityId == null || communityId <= 0) {
                return Result.fail("社区ID必须大于0");
            }
            
            if (status == null || (status != 0 && status != 1)) {
                return Result.fail("状态值必须为0（禁用）或1（启用）");
            }
            
            // 权限控制
            Long currentUserId = SecurityUtils.getCurrentUserId();
            if (currentUserId == null) {
                return Result.fail("用户未登录");
            }
            
            // 权限控制：只有管理员可以更新社区状态
            if (!SecurityUtils.hasRole("admin")) {
                return Result.fail("无权限更新社区状态");
            }
            
            boolean result = communityService.updateCommunityStatus(communityId, status);
            
            log.info("更新社区状态成功，社区ID：{}，状态：{}，操作人：{}", communityId, status, currentUserId);
            return Result.success("更新成功", result);
        } catch (Exception e) {
            log.error("更新社区状态失败，操作人：{}，社区ID：{}，状态：{}，错误信息：{}", SecurityUtils.getCurrentUserId(), communityId, status, e.getMessage(), e);
            return Result.fail("更新失败：" + e.getMessage());
        }
    }

    /**
     * 批量更新社区状态
     * 
     * @param communityIds 社区ID列表
     * @param status 状态：0-禁用，1-启用
     * @return 更新结果
     * @throws Exception 统一异常
     */
    @ApiLog(logTitle = "批量更新社区状态", logType = 2, moduleName = "区域管理", operationType = ApiLogOperationType.UPDATE)
    @PutMapping("/batch/status")
    @Operation(summary = "批量更新社区状态", description = "批量更新多个社区的状态")
    public Result<Boolean> batchUpdateCommunityStatus(@Parameter(description = "社区ID列表") @RequestBody List<Long> communityIds,
            @Parameter(description = "状态：0-禁用，1-启用") @RequestParam Integer status) throws Exception {
        try {
            log.info("开始批量更新社区状态，操作人：{}，社区ID列表：{}，状态：{}", SecurityUtils.getCurrentUserId(), communityIds, status);
            
            // 参数校验
            if (communityIds == null || communityIds.isEmpty()) {
                return Result.fail("社区ID列表不能为空");
            }
            
            if (status == null || (status != 0 && status != 1)) {
                return Result.fail("状态值必须为0（禁用）或1（启用）");
            }
            
            // 权限控制
            Long currentUserId = SecurityUtils.getCurrentUserId();
            if (currentUserId == null) {
                return Result.fail("用户未登录");
            }
            
            // 权限控制：只有管理员可以批量更新社区状态
            if (!SecurityUtils.hasRole("admin")) {
                return Result.fail("无权限批量更新社区状态");
            }
            
            boolean result = communityService.batchUpdateCommunityStatus(communityIds, status);
            
            log.info("批量更新社区状态成功，社区ID列表：{}，状态：{}，操作人：{}", communityIds, status, currentUserId);
            return Result.success("批量更新成功", result);
        } catch (Exception e) {
            log.error("批量更新社区状态失败，操作人：{}，社区ID列表：{}，状态：{}，错误信息：{}", SecurityUtils.getCurrentUserId(), communityIds, status, e.getMessage(), e);
            return Result.fail("批量更新失败：" + e.getMessage());
        }
    }

    // ==================== 验证接口 ====================

    /**
     * 检查社区编码唯一性
     * 
     * @param communityCode 社区编码
     * @param excludeCommunityId 排除的社区ID
     * @return 是否唯一
     * @throws Exception 统一异常
     */
    @GetMapping("/check/code")
    @Operation(summary = "检查社区编码唯一性", description = "检查社区编码是否已存在")
    public Result<Boolean> checkCommunityCodeUnique(@Parameter(description = "社区编码") @RequestParam String communityCode,
            @Parameter(description = "排除的社区ID") @RequestParam(required = false) Long excludeCommunityId) throws Exception {
        try {
            log.info("开始检查社区编码唯一性，操作人：{}，社区编码：{}，排除社区ID：{}", SecurityUtils.getCurrentUserId(), communityCode, excludeCommunityId);
            
            // 参数校验
            if (communityCode == null || communityCode.trim().isEmpty()) {
                return Result.fail("社区编码不能为空");
            }
            
            // 权限控制
            Long currentUserId = SecurityUtils.getCurrentUserId();
            if (currentUserId == null) {
                return Result.fail("用户未登录");
            }
            
            boolean isUnique = communityService.checkCommunityCodeUnique(communityCode, excludeCommunityId);
            
            log.info("检查社区编码唯一性成功，社区编码：{}，是否唯一：{}，操作人：{}", communityCode, isUnique, currentUserId);
            return Result.success("查询成功", isUnique);
        } catch (Exception e) {
            log.error("检查社区编码唯一性失败，操作人：{}，社区编码：{}，错误信息：{}", SecurityUtils.getCurrentUserId(), communityCode, e.getMessage(), e);
            return Result.fail("查询失败：" + e.getMessage());
        }
    }

    // ==================== 删除影响检查接口 ====================

    /**
     * 检查社区删除影响
     * 
     * @param communityId 社区ID
     * @return 删除影响分析
     * @throws Exception 统一异常
     */
    @GetMapping("/{communityId}/delete-impact")
    @Operation(summary = "检查社区删除影响", description = "分析删除社区会对哪些关联数据造成影响")
    @ApiLog(logTitle = "检查社区删除影响", logType = 2, moduleName = "区域管理", operationType = ApiLogOperationType.QUERY)
    public Result<CommunityDeleteImpactVO> checkDeleteImpact(@Parameter(description = "社区ID") @PathVariable Long communityId) throws Exception {
        try {
            log.info("开始检查社区删除影响，操作人：{}，社区ID：{}", SecurityUtils.getCurrentUserId(), communityId);
            
            // 参数校验
            if (communityId == null || communityId <= 0) {
                return Result.fail("社区ID必须大于0");
            }
            
            // 权限控制
            Long currentUserId = SecurityUtils.getCurrentUserId();
            if (currentUserId == null) {
                return Result.fail("用户未登录");
            }
            
            // 权限控制：只有管理员可以检查删除影响
            if (!SecurityUtils.hasRole("admin")) {
                return Result.fail("无权限检查社区删除影响");
            }
            
            CommunityDeleteImpactVO impact = communityService.checkDeleteImpact(communityId);
            
            log.info("检查社区删除影响成功，社区ID：{}，操作人：{}", communityId, currentUserId);
            return Result.success("查询成功", impact);
        } catch (Exception e) {
            log.error("检查社区删除影响失败，操作人：{}，社区ID：{}，错误信息：{}", SecurityUtils.getCurrentUserId(), communityId, e.getMessage(), e);
            return Result.fail("查询失败：" + e.getMessage());
        }
    }

    // ==================== 统计接口 ====================

    /**
     * 获取社区统计信息
     * 
     * @param communityId 社区ID
     * @return 统计信息
     * @throws Exception 统一异常
     */
    @GetMapping("/{communityId}/stats")
    @Operation(summary = "获取社区统计信息", description = "获取指定社区的统计信息")
    public Result<Object> getCommunityStats(@Parameter(description = "社区ID") @PathVariable Long communityId) throws Exception {
        try {
            log.info("开始获取社区统计信息，操作人：{}，社区ID：{}", SecurityUtils.getCurrentUserId(), communityId);
            
            // 参数校验
            if (communityId == null || communityId <= 0) {
                return Result.fail("社区ID必须大于0");
            }
            
            // 权限控制
            Long currentUserId = SecurityUtils.getCurrentUserId();
            if (currentUserId == null) {
                return Result.fail("用户未登录");
            }
            
            Object stats = communityService.getCommunityStats(communityId);
            
            log.info("获取社区统计信息成功，社区ID：{}，操作人：{}", communityId, currentUserId);
            return Result.success("查询成功", stats);
        } catch (Exception e) {
            log.error("获取社区统计信息失败，操作人：{}，社区ID：{}，错误信息：{}", SecurityUtils.getCurrentUserId(), communityId, e.getMessage(), e);
            return Result.fail("查询失败：" + e.getMessage());
        }
    }

    // ==================== 缓存管理接口 ====================

    /**
     * 清除社区缓存
     * 
     * @param communityId 社区ID
     * @return 清除结果
     * @throws Exception 统一异常
     */
    @ApiLog(logTitle = "清除社区缓存", logType = 2, moduleName = "区域管理", operationType = ApiLogOperationType.DELETE)
    @DeleteMapping("/cache/{communityId}")
    @Operation(summary = "清除社区缓存", description = "清除指定社区的缓存")
    public Result<Boolean> clearCommunityCache(@Parameter(description = "社区ID") @PathVariable Long communityId) throws Exception {
        try {
            log.info("开始清除社区缓存，操作人：{}，社区ID：{}", SecurityUtils.getCurrentUserId(), communityId);
            
            // 参数校验
            if (communityId == null || communityId <= 0) {
                return Result.fail("社区ID必须大于0");
            }
            
            // 权限控制
            Long currentUserId = SecurityUtils.getCurrentUserId();
            if (currentUserId == null) {
                return Result.fail("用户未登录");
            }
            
            // 权限控制：只有管理员可以清除缓存
            if (!SecurityUtils.hasRole("admin")) {
                return Result.fail("无权限清除社区缓存");
            }
            
            communityService.clearCommunityCache(communityId);
            
            log.info("清除社区缓存成功，社区ID：{}，操作人：{}", communityId, currentUserId);
            return Result.success("清除成功", true);
        } catch (Exception e) {
            log.error("清除社区缓存失败，操作人：{}，社区ID：{}，错误信息：{}", SecurityUtils.getCurrentUserId(), communityId, e.getMessage(), e);
            return Result.fail("清除失败：" + e.getMessage());
        }
    }

    /**
     * 清除所有社区缓存
     * 
     * @return 清除结果
     * @throws Exception 统一异常
     */
    @ApiLog(logTitle = "清除所有社区缓存", logType = 2, moduleName = "区域管理", operationType = ApiLogOperationType.DELETE)
    @DeleteMapping("/cache/all")
    @Operation(summary = "清除所有社区缓存", description = "清除所有社区相关的缓存")
    public Result<Boolean> clearAllCommunityCache() throws Exception {
        try {
            log.info("开始清除所有社区缓存，操作人：{}", SecurityUtils.getCurrentUserId());
            
            // 权限控制
            Long currentUserId = SecurityUtils.getCurrentUserId();
            if (currentUserId == null) {
                return Result.fail("用户未登录");
            }
            
            // 权限控制：只有管理员可以清除所有缓存
            if (!SecurityUtils.hasRole("admin")) {
                return Result.fail("无权限清除所有社区缓存");
            }
            
            communityService.clearAllCommunityCache();
            
            log.info("清除所有社区缓存成功，操作人：{}", currentUserId);
            return Result.success("清除成功", true);
        } catch (Exception e) {
            log.error("清除所有社区缓存失败，操作人：{}，错误信息：{}", SecurityUtils.getCurrentUserId(), e.getMessage(), e);
            return Result.fail("清除失败：" + e.getMessage());
        }
    }
    
    // ==================== 权限检查方法 ====================
    
    /**
     * 检查用户是否有创建社区的权限
     * 根据枚举规范实现权限验证
     * 
     * @return 是否有权限
     */
    private boolean hasCreateCommunityPermission() {
        try {
            // 获取当前用户ID
            Long currentUserId = SecurityUtils.getCurrentUserId();
            if (currentUserId == null) {
                log.warn("获取当前用户ID失败");
                return false;
            }
            
            // 获取用户角色列表
            List<String> userRoles = getUserRolesByUserId(currentUserId);
            if (userRoles == null || userRoles.isEmpty()) {
                log.warn("用户没有分配角色，用户ID：{}", currentUserId);
                return false;
            }
            
            // 使用枚举规范检查权限
            // 超级管理员、区域管理员、社区管理员、物业管理员、物业人员都可以创建社区
            for (String roleCode : userRoles) {
                if (com.smart.community.commons.enums.RoleCodeEnum.isSuperAdmin(roleCode) ||
                    com.smart.community.commons.enums.RoleCodeEnum.isRegionAdmin(roleCode) ||
                    com.smart.community.commons.enums.RoleCodeEnum.isCommunityAdmin(roleCode) ||
                    com.smart.community.commons.enums.RoleCodeEnum.isPropertyAdmin(roleCode) ||
                    com.smart.community.commons.enums.RoleCodeEnum.isPropertyStaff(roleCode)) {
                    return true;
                }
            }
            
            log.warn("用户没有创建社区的权限，用户ID：{}，角色：{}", currentUserId, userRoles);
            return false;
                   
        } catch (Exception e) {
            log.error("检查创建社区权限失败，错误：{}", e.getMessage());
            return false;
        }
    }
    
    /**
     * 根据用户ID获取用户角色代码列表
     * 
     * @param userId 用户ID
     * @return 角色代码列表
     */
    private List<String> getUserRolesByUserId(Long userId) {
        try {
            // 通过Feign接口获取用户角色
            List<com.smart.community.feign.user.dto.RoleDTO> roleDTOs = userFeignService.getUserRoles(userId);
            if (roleDTOs == null || roleDTOs.isEmpty()) {
                return new ArrayList<>();
            }
            
            // 提取角色代码
            return roleDTOs.stream()
                    .map(com.smart.community.feign.user.dto.RoleDTO::getRoleCode)
                    .filter(Objects::nonNull)
                    .collect(Collectors.toList());
                    
        } catch (Exception e) {
            log.error("获取用户角色失败，用户ID：{}，错误：{}", userId, e.getMessage());
            return new ArrayList<>();
        }
    }
}